package com.atguigu.tingshu.album.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import com.atguigu.tingshu.album.mapper.AlbumAttributeValueMapper;
import com.atguigu.tingshu.album.mapper.AlbumInfoMapper;
import com.atguigu.tingshu.album.mapper.AlbumStatMapper;
import com.atguigu.tingshu.album.mapper.TrackInfoMapper;
import com.atguigu.tingshu.album.service.AlbumInfoService;
import com.atguigu.tingshu.common.constant.KafkaConstant;
import com.atguigu.tingshu.common.constant.SystemConstant;
import com.atguigu.tingshu.common.execption.GuiguException;
import com.atguigu.tingshu.common.service.KafkaService;
import com.atguigu.tingshu.common.util.AuthContextHolder;
import com.atguigu.tingshu.model.album.AlbumAttributeValue;
import com.atguigu.tingshu.model.album.AlbumInfo;
import com.atguigu.tingshu.model.album.AlbumStat;
import com.atguigu.tingshu.model.album.TrackInfo;
import com.atguigu.tingshu.query.album.AlbumInfoQuery;
import com.atguigu.tingshu.vo.album.AlbumAttributeValueVo;
import com.atguigu.tingshu.vo.album.AlbumInfoVo;
import com.atguigu.tingshu.vo.album.AlbumListVo;
import com.atguigu.tingshu.vo.album.AlbumStatVo;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Slf4j
@Service
@Transactional(rollbackFor = Exception.class)
@SuppressWarnings({"all"})
public class AlbumInfoServiceImpl extends ServiceImpl<AlbumInfoMapper, AlbumInfo> implements AlbumInfoService {

    @Autowired
    private AlbumInfoMapper albumInfoMapper;

    @Autowired
    private AlbumAttributeValueMapper albumAttributeValueMapper;

    @Autowired
    private AlbumStatMapper albumStatMapper;

    @Autowired
    private TrackInfoMapper trackInfoMapper;


    @Autowired
    private KafkaService kafkaService;

    @Override
    public void saveAlbumInfo(Long userId, AlbumInfoVo albumInfoVo) {

        //1.首先将提交的专辑信息封装到的AlbumInfoVo对象，保存一条记录到Album_info表中
        //1.1将提交的vo对象转换成po（持久层）对象
        AlbumInfo albumInfo = BeanUtil.copyProperties(albumInfoVo, AlbumInfo.class);
        //1.2手动给其赋值

        albumInfo.setStatus(SystemConstant.ALBUM_STATUS_PASS);//TODO 专辑审核状态，待审核
        albumInfo.setUserId(userId);//创作者id
        albumInfo.setTracksForFree(5);//免费试听集数
        //1.3保存专辑获得专辑id
        albumInfoMapper.insert(albumInfo);
        Long albumId = albumInfo.getId();
        //2.将提交的AlbumAttributeValueVo标签集合，保存到album_attribute_value表中
        //2.1获取提交对象中的albumAttributeValueVoList标签集合
        List<AlbumAttributeValueVo> albumAttributeValueVoList = albumInfoVo.getAlbumAttributeValueVoList();
		//2.2判断集合中是否有值
		if (CollectionUtil.isNotEmpty(albumAttributeValueVoList)){
            //2.3将vo对象转化为po对象
            //遍历获取vo对象
            for (AlbumAttributeValueVo albumAttributeValuevo : albumAttributeValueVoList) {
                AlbumAttributeValue albumAttributeValue = BeanUtil.copyProperties(albumAttributeValuevo, AlbumAttributeValue.class);
                //获取保存的专辑的id绑定表现信息
                albumAttributeValue.setAlbumId(albumId);
                //调用持久层或者业务层保存标签信息
                albumAttributeValueMapper.insert(albumAttributeValue);
            }
            //3.批量保存专辑统计信息到album_stat表中
            this.saveAlbumStat(albumId,SystemConstant.ALBUM_STAT_PLAY,1);
            this.saveAlbumStat(albumId,SystemConstant.ALBUM_STAT_SUBSCRIBE,1);
            this.saveAlbumStat(albumId,SystemConstant.ALBUM_STAT_BUY,1);
            this.saveAlbumStat(albumId,SystemConstant.ALBUM_STAT_COMMENT,1);
        }

        //5.审核通过后发送上架专辑消息到Kafka
        if (true && "1".equals(albumInfo.getIsOpen())) {
            kafkaService.sendKafkaMessage(KafkaConstant.QUEUE_ALBUM_UPPER, albumId.toString());
        }

    }

    @Override
    public void saveAlbumStat(Long albumId, String albumStatType, int num) {
        //1.创建stat对象
        AlbumStat albumStat = new AlbumStat();
        albumStat.setAlbumId(albumId);
        albumStat.setStatType(albumStatType);
        albumStat.setStatNum(num);
        albumStatMapper.insert(albumStat);
    }

    @Override
    public Page<AlbumListVo> getUserAlbumPage(AlbumInfoQuery albumInfoQuery, Page<AlbumListVo> pageInfo) {
        return albumInfoMapper.getUserAlbumPage(pageInfo,albumInfoQuery);
    }

    @Override
    public void removeAlbumInfo(Long id) {
        //判断专辑下是否关联声音
        LambdaQueryWrapper<TrackInfo> lambdaQueryWrapper = new LambdaQueryWrapper();
        lambdaQueryWrapper.eq(TrackInfo::getAlbumId,id);
        Long trackNum = trackInfoMapper.selectCount(lambdaQueryWrapper);
        if (trackNum>0){
            throw new GuiguException(400,"该专辑下关联声音，请勿删除");
        }
        //删除专辑信息表
        albumInfoMapper.deleteById(id);
        //删除专辑标签关联表
        LambdaQueryWrapper<AlbumAttributeValue> albumAttributeValueLambdaQueryWrapper
                = new LambdaQueryWrapper<>();
        albumAttributeValueLambdaQueryWrapper.eq(AlbumAttributeValue::getAlbumId,id);
        albumAttributeValueMapper.delete(albumAttributeValueLambdaQueryWrapper);

        //删除专辑统计表
        LambdaQueryWrapper<AlbumStat> statLambdaQueryWrapper
                 =new LambdaQueryWrapper<>();
        statLambdaQueryWrapper.eq(AlbumStat::getAlbumId,id);
        albumStatMapper.delete(statLambdaQueryWrapper);
        //删除索引库中的专辑文档
        kafkaService.sendKafkaMessage(KafkaConstant.QUEUE_ALBUM_LOWER,id.toString());
    }

    @Override
    public AlbumInfo getAlbumInfo(Long id) {
        //查询所有的专辑数据
        AlbumInfo albumInfo = albumInfoMapper.selectById(id);

        //查询标签列表
        LambdaQueryWrapper<AlbumAttributeValue> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(AlbumAttributeValue::getAlbumId,id);
        List<AlbumAttributeValue> albumAttributeValues = albumAttributeValueMapper.selectList(lambdaQueryWrapper);
        if (CollectionUtil.isNotEmpty(albumAttributeValues)){
            albumInfo.setAlbumAttributeValueVoList(albumAttributeValues);
        }
        return albumInfo;
    }

    @Override
    public void albumInfoService(AlbumInfo albumInfo) {
        //根据id直接修改专辑信息表
        albumInfoMapper.updateById(albumInfo);
        //先删除标签关系表中关联的数据，在进行新增数据
        //根据专辑id进行删除
        LambdaQueryWrapper<AlbumAttributeValue> albumAttributeValueLambdaQueryWrapper
                = new LambdaQueryWrapper<>();
        albumAttributeValueLambdaQueryWrapper.eq(AlbumAttributeValue::getAlbumId,albumInfo.getId());
        albumAttributeValueMapper.delete(albumAttributeValueLambdaQueryWrapper);
        //新增关系表的数据

        List<AlbumAttributeValue> albumAttributeValueVoList = albumInfo.getAlbumAttributeValueVoList();
        if (CollectionUtil.isNotEmpty(albumAttributeValueVoList)){

            for (AlbumAttributeValue albumAttributeValue : albumAttributeValueVoList) {
                //获取保存的专辑的id绑定表现信息
                albumAttributeValue.setAlbumId(albumInfo.getId());
                //调用持久层或者业务层保存标签信息
                albumAttributeValueMapper.insert(albumAttributeValue);
            }
        }
        // 如果是开放专辑自动将专辑同步到ES索引库中
        if("1".equals(albumInfo.getIsOpen())){
            kafkaService.sendKafkaMessage(KafkaConstant.QUEUE_ALBUM_UPPER,albumInfo.getId().toString());
        }else{
            kafkaService.sendKafkaMessage(KafkaConstant.QUEUE_ALBUM_LOWER,albumInfo.getId().toString());
        }
    }

    @Override
    public List<AlbumInfo> findUserAllAlbumList() {

        //获取当前用户id
        Long userId = AuthContextHolder.getUserId();

        LambdaQueryWrapper<AlbumInfo> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //设置查询条件
        lambdaQueryWrapper.eq(AlbumInfo::getUserId,userId);
        //设置根据id进行排序
        lambdaQueryWrapper.orderByDesc(AlbumInfo::getId);
        //设置查询字段
        lambdaQueryWrapper.select(AlbumInfo::getId,AlbumInfo::getAlbumTitle);
        //限制查询的条数
        lambdaQueryWrapper.last("limit 100");
        //返回结果

        return  albumInfoMapper.selectList(lambdaQueryWrapper);
    }

    @Override
    public AlbumStatVo getAlbumStatVo(Long albumId) {
        //根据专辑id获取专辑统计信息
        return albumInfoMapper.getAlbumStatVo(albumId);
    }
}
